package com.ruoyi.tzai.service.tts;

import com.ruoyi.tzai.domain.ApiKeyPool;
import com.ruoyi.tzai.domain.TTSEngineConfig;
import com.ruoyi.tzai.service.IApiKeyPoolService;
import com.ruoyi.tzai.service.ITTSEngineConfigService;
import com.ruoyi.tzai.service.IFileUploadService;
import com.ruoyi.tzai.service.tts.impl.AzureTTSServiceImpl;
import com.ruoyi.tzai.service.tts.impl.AliyunTTSServiceImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * TTS服务工厂
 * 根据数据库配置动态创建TTS服务实例
 * 
 * @author tzai
 * @date 2025-10-27
 */
@Component
public class TTSServiceFactory 
{
    private static final Logger log = LoggerFactory.getLogger(TTSServiceFactory.class);

    @Autowired
    private ITTSEngineConfigService ttsEngineConfigService;
    
    @Autowired
    private IFileUploadService fileUploadService;

    @Autowired
    private IApiKeyPoolService apiKeyPoolService;

    /** 服务实例缓存（注意：不缓存带Key的实例，因为Key是动态的） */
    private final Map<Long, ITTSService> serviceCache = new ConcurrentHashMap<>();

    /**
     * 获取默认TTS服务
     * 
     * @return TTS服务实例
     */
    public ITTSService getDefaultService() {
        TTSEngineConfig config = ttsEngineConfigService.selectDefaultTTSEngineConfig();
        if (config == null) {
            log.error("未找到默认TTS引擎配置");
            return null;
        }
        return getService(config.getEngineId());
    }

    /**
     * 根据引擎ID获取TTS服务（自动从Key池获取第一个可用Key）
     * 注意：此方法适用于简单场景，不支持Key的释放管理
     * 
     * @param engineId 引擎ID
     * @return TTS服务实例
     */
    public ITTSService getService(Long engineId) {
        // 从数据库加载配置
        TTSEngineConfig config = ttsEngineConfigService.selectTTSEngineConfigByEngineId(engineId);
        if (config == null) {
            log.error("未找到TTS引擎配置: {}", engineId);
            return null;
        }

        // 从Key池获取一个可用的Key
        List<ApiKeyPool> keys = apiKeyPoolService.acquireKeys("tts_engine", engineId, 1);
        if (keys == null || keys.isEmpty()) {
            log.error("未找到可用的API Key for TTS engine: {}", engineId);
            return null;
        }

        ApiKeyPool keyPool = keys.get(0);
        ITTSService service = createServiceWithKey(config, keyPool.getApiKey());
        
        // 注意：这里获取的Key不会自动释放，调用者需要手动管理
        // 建议使用任务队列系统进行复杂的Key管理
        
        return service;
    }

    /**
     * 使用指定的API Key创建TTS服务
     * 
     * @param config TTS引擎配置
     * @param apiKey API Key
     * @return TTS服务实例
     */
    public ITTSService createServiceWithKey(TTSEngineConfig config, String apiKey) {
        try {
            String provider = config.getProvider();
            
            if ("azure".equalsIgnoreCase(provider) || "microsoft".equalsIgnoreCase(provider)) {
                return createAzureTTSService(config, apiKey);
            } else if ("google".equalsIgnoreCase(provider)) {
                // TODO: 实现Google Cloud TTS服务
                log.warn("Google Cloud TTS服务暂未实现");
                return null;
            } else if ("aliyun".equalsIgnoreCase(provider) 
                    || "AliyunTTS".equalsIgnoreCase(provider)
                    || provider.contains("阿里云")
                    || provider.contains("通义")
                    || provider.contains("DashScope")) {
                // 支持多种阿里云TTS的provider名称
                return createAliyunTTSService(config, apiKey);
            } else {
                log.error("不支持的TTS提供商: {}", provider);
                return null;
            }
        } catch (Exception e) {
            log.error("创建TTS服务失败", e);
            return null;
        }
    }

    /**
     * 获取支持时间戳的TTS服务
     * 
     * @return TTS服务实例
     */
    public ITTSService getServiceWithTimestamp() {
        java.util.List<TTSEngineConfig> configs = ttsEngineConfigService.selectTTSEngineConfigWithTimestamp();
        if (configs == null || configs.isEmpty()) {
            log.error("未找到支持时间戳的TTS引擎");
            return getDefaultService();
        }
        
        // 返回第一个支持时间戳的引擎
        return getService(configs.get(0).getEngineId());
    }

    /**
     * 创建Azure TTS服务
     */
    private ITTSService createAzureTTSService(TTSEngineConfig config, String apiKey) {
        try {
            AzureTTSServiceImpl service = new AzureTTSServiceImpl();
            
            // 注入文件上传服务（解决Spring不注入依赖的问题）
            service.setFileUploadService(fileUploadService);
            
            // 设置API Key（从Key池获取）
            if (apiKey != null && !apiKey.isEmpty()) {
                service.setSubscriptionKey(apiKey);
            }
            
            if (config.getRegion() != null && !config.getRegion().isEmpty()) {
                service.setRegion(config.getRegion());
            }
            
            if (config.getApiEndpoint() != null && !config.getApiEndpoint().isEmpty()) {
                service.setApiEndpoint(config.getApiEndpoint());
            }

            log.info("创建Azure TTS服务成功: {}", config.getEngineName());
            return service;
        } catch (Exception e) {
            log.error("创建Azure TTS服务失败", e);
            return null;
        }
    }

    /**
     * 创建阿里云Qwen3-TTS服务
     */
    private ITTSService createAliyunTTSService(TTSEngineConfig config, String apiKey) {
        try {
            AliyunTTSServiceImpl service = new AliyunTTSServiceImpl();
            
            // 注入文件上传服务（解决Spring不注入依赖的问题）
            service.setFileUploadService(fileUploadService);
            
            // 设置API Key（从Key池获取）
            if (apiKey != null && !apiKey.isEmpty()) {
                service.setApiKey(apiKey);
                log.info("Qwen3-TTS API Key已设置: {}...", apiKey.substring(0, Math.min(10, apiKey.length())));
            } else {
                log.warn("未配置API Key，Qwen3-TTS可能无法正常工作");
            }
            
            // 设置端点（如果有自定义配置）
            if (config.getApiEndpoint() != null && !config.getApiEndpoint().isEmpty()) {
                // 可以在这里设置自定义端点
                log.info("使用自定义API端点: {}", config.getApiEndpoint());
            }

            log.info("创建Qwen3-TTS服务成功: {} (Model: qwen3-tts-flash)", config.getEngineName());
            return service;
        } catch (Exception e) {
            log.error("创建Qwen3-TTS服务失败", e);
            return null;
        }
    }

    /**
     * 清除缓存
     * 
     * @param engineId 引擎ID
     */
    public void clearCache(Long engineId) {
        serviceCache.remove(engineId);
        log.info("清除TTS服务缓存: {}", engineId);
    }

    /**
     * 清除所有缓存
     */
    public void clearAllCache() {
        serviceCache.clear();
        log.info("清除所有TTS服务缓存");
    }
}

